1 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
2 package net.sourceforge.jane.jjtree;
3
4 public class JavaParserTokenManager implements JavaParserConstants
5 {
6 public java.io.PrintStream debugStream = System.out;
7 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
9 {
10 switch (pos)
11 {
12 case 0:
13 if ((active0 & 0x140L) != 0L || (active1 & 0x4008000000000L) != 0L)
14 return 2;
15 if ((active1 & 0x100000L) != 0L)
16 return 8;
17 if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
18 {
19 jjmatchedKind = 73;
20 return 32;
21 }
22 return -1;
23 case 1:
24 if ((active0 & 0x100L) != 0L)
25 return 0;
26 if ((active0 & 0xfffffffbfcffe000L) != 0L || (active1 & 0x1L) != 0L)
27 {
28 if (jjmatchedPos != 1)
29 {
30 jjmatchedKind = 73;
31 jjmatchedPos = 1;
32 }
33 return 32;
34 }
35 if ((active0 & 0x403000000L) != 0L)
36 return 32;
37 return -1;
38 case 2:
39 if ((active0 & 0xf7fffb3afeffe000L) != 0L || (active1 & 0x1L) != 0L)
40 {
41 if (jjmatchedPos != 2)
42 {
43 jjmatchedKind = 73;
44 jjmatchedPos = 2;
45 }
46 return 32;
47 }
48 if ((active0 & 0x80004c100000000L) != 0L)
49 return 32;
50 return -1;
51 case 3:
52 if ((active0 & 0xe3bff2b8faf4e000L) != 0L || (active1 & 0x1L) != 0L)
53 {
54 jjmatchedKind = 73;
55 jjmatchedPos = 3;
56 return 32;
57 }
58 if ((active0 & 0x14400902040b0000L) != 0L)
59 return 32;
60 return -1;
61 case 4:
62 if ((active0 & 0xa235f2b80ac06000L) != 0L || (active1 & 0x1L) != 0L)
63 {
64 if (jjmatchedPos != 4)
65 {
66 jjmatchedKind = 73;
67 jjmatchedPos = 4;
68 }
69 return 32;
70 }
71 if ((active0 & 0x418a0000f0348000L) != 0L)
72 return 32;
73 return -1;
74 case 5:
75 if ((active0 & 0xa22070a848c06000L) != 0L)
76 {
77 jjmatchedKind = 73;
78 jjmatchedPos = 5;
79 return 32;
80 }
81 if ((active0 & 0x115821002000000L) != 0L || (active1 & 0x1L) != 0L)
82 return 32;
83 return -1;
84 case 6:
85 if ((active0 & 0xa22040a800402000L) != 0L)
86 {
87 jjmatchedKind = 73;
88 jjmatchedPos = 6;
89 return 32;
90 }
91 if ((active0 & 0x300048804000L) != 0L)
92 return 32;
93 return -1;
94 case 7:
95 if ((active0 & 0x22040a800000000L) != 0L)
96 {
97 jjmatchedKind = 73;
98 jjmatchedPos = 7;
99 return 32;
100 }
101 if ((active0 & 0xa000000000402000L) != 0L)
102 return 32;
103 return -1;
104 case 8:
105 if ((active0 & 0x20002800000000L) != 0L)
106 {
107 jjmatchedKind = 73;
108 jjmatchedPos = 8;
109 return 32;
110 }
111 if ((active0 & 0x200408000000000L) != 0L)
112 return 32;
113 return -1;
114 case 9:
115 if ((active0 & 0x20000000000000L) != 0L)
116 {
117 jjmatchedKind = 73;
118 jjmatchedPos = 9;
119 return 32;
120 }
121 if ((active0 & 0x2800000000L) != 0L)
122 return 32;
123 return -1;
124 case 10:
125 if ((active0 & 0x20000000000000L) != 0L)
126 {
127 jjmatchedKind = 73;
128 jjmatchedPos = 10;
129 return 32;
130 }
131 return -1;
132 default :
133 return -1;
134 }
135 }
136 private final int jjStartNfa_0(int pos, long active0, long active1)
137 {
138 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
139 }
140 private final int jjStopAtPos(int pos, int kind)
141 {
142 jjmatchedKind = kind;
143 jjmatchedPos = pos;
144 return pos + 1;
145 }
146 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
147 {
148 jjmatchedKind = kind;
149 jjmatchedPos = pos;
150 try { curChar = input_stream.readChar(); }
151 catch(java.io.IOException e) { return pos + 1; }
152 return jjMoveNfa_0(state, pos + 1);
153 }
154 private final int jjMoveStringLiteralDfa0_0()
155 {
156 switch(curChar)
157 {
158 case 33:
159 jjmatchedKind = 88;
160 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
161 case 37:
162 jjmatchedKind = 107;
163 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
164 case 38:
165 jjmatchedKind = 104;
166 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
167 case 40:
168 return jjStopAtPos(0, 76);
169 case 41:
170 return jjStopAtPos(0, 77);
171 case 42:
172 jjmatchedKind = 102;
173 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
174 case 43:
175 jjmatchedKind = 100;
176 return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
177 case 44:
178 return jjStopAtPos(0, 83);
179 case 45:
180 jjmatchedKind = 101;
181 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
182 case 46:
183 return jjStartNfaWithStates_0(0, 84, 8);
184 case 47:
185 jjmatchedKind = 103;
186 return jjMoveStringLiteralDfa1_0(0x140L, 0x4000000000000L);
187 case 58:
188 return jjStopAtPos(0, 91);
189 case 59:
190 return jjStopAtPos(0, 82);
191 case 60:
192 jjmatchedKind = 87;
193 return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
194 case 61:
195 jjmatchedKind = 85;
196 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
197 case 62:
198 jjmatchedKind = 86;
199 return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
200 case 63:
201 return jjStopAtPos(0, 90);
202 case 91:
203 return jjStopAtPos(0, 80);
204 case 93:
205 return jjStopAtPos(0, 81);
206 case 94:
207 jjmatchedKind = 106;
208 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
209 case 97:
210 return jjMoveStringLiteralDfa1_0(0x2000L, 0x1L);
211 case 98:
212 return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L);
213 case 99:
214 return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L);
215 case 100:
216 return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L);
217 case 101:
218 return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
219 case 102:
220 return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L);
221 case 103:
222 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
223 case 105:
224 return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L);
225 case 108:
226 return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L);
227 case 110:
228 return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L);
229 case 112:
230 return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L);
231 case 114:
232 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
233 case 115:
234 return jjMoveStringLiteralDfa1_0(0x803e000000000000L, 0x0L);
235 case 116:
236 return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L);
237 case 118:
238 return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L);
239 case 119:
240 return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
241 case 123:
242 return jjStopAtPos(0, 78);
243 case 124:
244 jjmatchedKind = 105;
245 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
246 case 125:
247 return jjStopAtPos(0, 79);
248 case 126:
249 return jjStopAtPos(0, 89);
250 default :
251 return jjMoveNfa_0(3, 0);
252 }
253 }
254 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
255 {
256 try { curChar = input_stream.readChar(); }
257 catch(java.io.IOException e) {
258 jjStopStringLiteralDfa_0(0, active0, active1);
259 return 1;
260 }
261 switch(curChar)
262 {
263 case 38:
264 if ((active1 & 0x200000000L) != 0L)
265 return jjStopAtPos(1, 97);
266 break;
267 case 42:
268 if ((active0 & 0x100L) != 0L)
269 return jjStartNfaWithStates_0(1, 8, 0);
270 break;
271 case 43:
272 if ((active1 & 0x400000000L) != 0L)
273 return jjStopAtPos(1, 98);
274 break;
275 case 45:
276 if ((active1 & 0x800000000L) != 0L)
277 return jjStopAtPos(1, 99);
278 break;
279 case 47:
280 if ((active0 & 0x40L) != 0L)
281 return jjStopAtPos(1, 6);
282 break;
283 case 60:
284 if ((active1 & 0x100000000000L) != 0L)
285 {
286 jjmatchedKind = 108;
287 jjmatchedPos = 1;
288 }
289 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
290 case 61:
291 if ((active1 & 0x10000000L) != 0L)
292 return jjStopAtPos(1, 92);
293 else if ((active1 & 0x20000000L) != 0L)
294 return jjStopAtPos(1, 93);
295 else if ((active1 & 0x40000000L) != 0L)
296 return jjStopAtPos(1, 94);
297 else if ((active1 & 0x80000000L) != 0L)
298 return jjStopAtPos(1, 95);
299 else if ((active1 & 0x800000000000L) != 0L)
300 return jjStopAtPos(1, 111);
301 else if ((active1 & 0x1000000000000L) != 0L)
302 return jjStopAtPos(1, 112);
303 else if ((active1 & 0x2000000000000L) != 0L)
304 return jjStopAtPos(1, 113);
305 else if ((active1 & 0x4000000000000L) != 0L)
306 return jjStopAtPos(1, 114);
307 else if ((active1 & 0x8000000000000L) != 0L)
308 return jjStopAtPos(1, 115);
309 else if ((active1 & 0x10000000000000L) != 0L)
310 return jjStopAtPos(1, 116);
311 else if ((active1 & 0x20000000000000L) != 0L)
312 return jjStopAtPos(1, 117);
313 else if ((active1 & 0x40000000000000L) != 0L)
314 return jjStopAtPos(1, 118);
315 break;
316 case 62:
317 if ((active1 & 0x200000000000L) != 0L)
318 {
319 jjmatchedKind = 109;
320 jjmatchedPos = 1;
321 }
322 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300400000000000L);
323 case 97:
324 return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 0L);
325 case 98:
326 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
327 case 101:
328 return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000L, active1, 0L);
329 case 102:
330 if ((active0 & 0x400000000L) != 0L)
331 return jjStartNfaWithStates_0(1, 34, 32);
332 break;
333 case 104:
334 return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, active1, 0L);
335 case 105:
336 return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L);
337 case 108:
338 return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L);
339 case 109:
340 return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L);
341 case 110:
342 return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0L);
343 case 111:
344 if ((active0 & 0x1000000L) != 0L)
345 {
346 jjmatchedKind = 24;
347 jjmatchedPos = 1;
348 }
349 return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, active1, 0L);
350 case 114:
351 return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, active1, 0L);
352 case 115:
353 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1L);
354 case 116:
355 return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000000L, active1, 0L);
356 case 117:
357 return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 0L);
358 case 119:
359 return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0L);
360 case 120:
361 return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L);
362 case 121:
363 return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 0L);
364 case 124:
365 if ((active1 & 0x100000000L) != 0L)
366 return jjStopAtPos(1, 96);
367 break;
368 default :
369 break;
370 }
371 return jjStartNfa_0(0, active0, active1);
372 }
373 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
374 {
375 if (((active0 &= old0) | (active1 &= old1)) == 0L)
376 return jjStartNfa_0(0, old0, old1);
377 try { curChar = input_stream.readChar(); }
378 catch(java.io.IOException e) {
379 jjStopStringLiteralDfa_0(1, active0, active1);
380 return 2;
381 }
382 switch(curChar)
383 {
384 case 61:
385 if ((active1 & 0x80000000000000L) != 0L)
386 return jjStopAtPos(2, 119);
387 else if ((active1 & 0x100000000000000L) != 0L)
388 return jjStopAtPos(2, 120);
389 break;
390 case 62:
391 if ((active1 & 0x400000000000L) != 0L)
392 {
393 jjmatchedKind = 110;
394 jjmatchedPos = 2;
395 }
396 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
397 case 97:
398 return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, active1, 0L);
399 case 98:
400 return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L);
401 case 99:
402 return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L);
403 case 101:
404 return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L);
405 case 102:
406 return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L);
407 case 105:
408 return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, active1, 0L);
409 case 108:
410 return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, active1, 0L);
411 case 110:
412 return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 0L);
413 case 111:
414 return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 0L);
415 case 112:
416 return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 0L);
417 case 114:
418 if ((active0 & 0x100000000L) != 0L)
419 return jjStartNfaWithStates_0(2, 32, 32);
420 return jjMoveStringLiteralDfa3_0(active0, 0x8180000000000000L, active1, 0L);
421 case 115:
422 return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0x1L);
423 case 116:
424 if ((active0 & 0x4000000000L) != 0L)
425 {
426 jjmatchedKind = 38;
427 jjmatchedPos = 2;
428 }
429 return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000L, active1, 0L);
430 case 117:
431 return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, active1, 0L);
432 case 119:
433 if ((active0 & 0x40000000000L) != 0L)
434 return jjStartNfaWithStates_0(2, 42, 32);
435 break;
436 case 121:
437 if ((active0 & 0x800000000000000L) != 0L)
438 return jjStartNfaWithStates_0(2, 59, 32);
439 break;
440 default :
441 break;
442 }
443 return jjStartNfa_0(1, active0, active1);
444 }
445 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
446 {
447 if (((active0 &= old0) | (active1 &= old1)) == 0L)
448 return jjStartNfa_0(1, old0, old1);
449 try { curChar = input_stream.readChar(); }
450 catch(java.io.IOException e) {
451 jjStopStringLiteralDfa_0(2, active0, active1);
452 return 3;
453 }
454 switch(curChar)
455 {
456 case 61:
457 if ((active1 & 0x200000000000000L) != 0L)
458 return jjStopAtPos(3, 121);
459 break;
460 case 97:
461 return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000L, active1, 0L);
462 case 98:
463 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L);
464 case 99:
465 return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 0L);
466 case 100:
467 if ((active0 & 0x1000000000000000L) != 0L)
468 return jjStartNfaWithStates_0(3, 60, 32);
469 break;
470 case 101:
471 if ((active0 & 0x10000L) != 0L)
472 return jjStartNfaWithStates_0(3, 16, 32);
473 else if ((active0 & 0x20000L) != 0L)
474 return jjStartNfaWithStates_0(3, 17, 32);
475 else if ((active0 & 0x4000000L) != 0L)
476 return jjStartNfaWithStates_0(3, 26, 32);
477 else if ((active0 & 0x400000000000000L) != 0L)
478 return jjStartNfaWithStates_0(3, 58, 32);
479 return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 0x1L);
480 case 103:
481 if ((active0 & 0x10000000000L) != 0L)
482 return jjStartNfaWithStates_0(3, 40, 32);
483 break;
484 case 105:
485 return jjMoveStringLiteralDfa4_0(active0, 0x8000020000000000L, active1, 0L);
486 case 107:
487 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
488 case 108:
489 if ((active0 & 0x80000000000L) != 0L)
490 return jjStartNfaWithStates_0(3, 43, 32);
491 return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, active1, 0L);
492 case 110:
493 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0L);
494 case 111:
495 if ((active0 & 0x200000000L) != 0L)
496 return jjStartNfaWithStates_0(3, 33, 32);
497 return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, active1, 0L);
498 case 114:
499 if ((active0 & 0x80000L) != 0L)
500 return jjStartNfaWithStates_0(3, 19, 32);
501 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
502 case 115:
503 if ((active0 & 0x40000000000000L) != 0L)
504 return jjStartNfaWithStates_0(3, 54, 32);
505 return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L);
506 case 116:
507 return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 0L);
508 case 117:
509 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
510 case 118:
511 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
512 default :
513 break;
514 }
515 return jjStartNfa_0(2, active0, active1);
516 }
517 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
518 {
519 if (((active0 &= old0) | (active1 &= old1)) == 0L)
520 return jjStartNfa_0(2, old0, old1);
521 try { curChar = input_stream.readChar(); }
522 catch(java.io.IOException e) {
523 jjStopStringLiteralDfa_0(3, active0, active1);
524 return 4;
525 }
526 switch(curChar)
527 {
528 case 97:
529 return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0L);
530 case 99:
531 return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L, active1, 0L);
532 case 101:
533 if ((active0 & 0x10000000L) != 0L)
534 return jjStartNfaWithStates_0(4, 28, 32);
535 else if ((active0 & 0x4000000000000000L) != 0L)
536 return jjStartNfaWithStates_0(4, 62, 32);
537 return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L, active1, 0L);
538 case 104:
539 if ((active0 & 0x40000L) != 0L)
540 return jjStartNfaWithStates_0(4, 18, 32);
541 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L);
542 case 105:
543 return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L, active1, 0L);
544 case 107:
545 if ((active0 & 0x8000L) != 0L)
546 return jjStartNfaWithStates_0(4, 15, 32);
547 break;
548 case 108:
549 if ((active0 & 0x20000000L) != 0L)
550 {
551 jjmatchedKind = 29;
552 jjmatchedPos = 4;
553 }
554 return jjMoveStringLiteralDfa5_0(active0, 0x42000000L, active1, 0L);
555 case 110:
556 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L);
557 case 114:
558 if ((active0 & 0x8000000000000L) != 0L)
559 return jjStartNfaWithStates_0(4, 51, 32);
560 return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L, active1, 0x1L);
561 case 115:
562 if ((active0 & 0x100000L) != 0L)
563 return jjStartNfaWithStates_0(4, 20, 32);
564 return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L);
565 case 116:
566 if ((active0 & 0x200000L) != 0L)
567 return jjStartNfaWithStates_0(4, 21, 32);
568 else if ((active0 & 0x80000000L) != 0L)
569 return jjStartNfaWithStates_0(4, 31, 32);
570 else if ((active0 & 0x2000000000000L) != 0L)
571 return jjStartNfaWithStates_0(4, 49, 32);
572 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L);
573 case 117:
574 return jjMoveStringLiteralDfa5_0(active0, 0x800000L, active1, 0L);
575 case 118:
576 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L);
577 case 119:
578 if ((active0 & 0x80000000000000L) != 0L)
579 {
580 jjmatchedKind = 55;
581 jjmatchedPos = 4;
582 }
583 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
584 default :
585 break;
586 }
587 return jjStartNfa_0(3, active0, active1);
588 }
589 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
590 {
591 if (((active0 &= old0) | (active1 &= old1)) == 0L)
592 return jjStartNfa_0(3, old0, old1);
593 try { curChar = input_stream.readChar(); }
594 catch(java.io.IOException e) {
595 jjStopStringLiteralDfa_0(4, active0, active1);
596 return 5;
597 }
598 switch(curChar)
599 {
600 case 97:
601 return jjMoveStringLiteralDfa6_0(active0, 0x6000L, active1, 0L);
602 case 99:
603 if ((active0 & 0x800000000000L) != 0L)
604 return jjStartNfaWithStates_0(5, 47, 32);
605 else if ((active0 & 0x4000000000000L) != 0L)
606 return jjStartNfaWithStates_0(5, 50, 32);
607 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
608 case 100:
609 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0L);
610 case 101:
611 if ((active0 & 0x2000000L) != 0L)
612 return jjStartNfaWithStates_0(5, 25, 32);
613 else if ((active0 & 0x20000000000L) != 0L)
614 return jjStartNfaWithStates_0(5, 41, 32);
615 break;
616 case 102:
617 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
618 case 103:
619 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L);
620 case 104:
621 if ((active0 & 0x10000000000000L) != 0L)
622 return jjStartNfaWithStates_0(5, 52, 32);
623 break;
624 case 105:
625 return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L, active1, 0L);
626 case 108:
627 return jjMoveStringLiteralDfa6_0(active0, 0x40800000L, active1, 0L);
628 case 109:
629 return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L);
630 case 110:
631 if ((active0 & 0x1000000000000L) != 0L)
632 return jjStartNfaWithStates_0(5, 48, 32);
633 return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L, active1, 0L);
634 case 114:
635 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
636 case 115:
637 if ((active0 & 0x100000000000000L) != 0L)
638 return jjStartNfaWithStates_0(5, 56, 32);
639 break;
640 case 116:
641 if ((active0 & 0x1000000000L) != 0L)
642 return jjStartNfaWithStates_0(5, 36, 32);
643 else if ((active1 & 0x1L) != 0L)
644 return jjStartNfaWithStates_0(5, 64, 32);
645 return jjMoveStringLiteralDfa6_0(active0, 0x8000200000000000L, active1, 0L);
646 default :
647 break;
648 }
649 return jjStartNfa_0(4, active0, active1);
650 }
651 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
652 {
653 if (((active0 &= old0) | (active1 &= old1)) == 0L)
654 return jjStartNfa_0(4, old0, old1);
655 try { curChar = input_stream.readChar(); }
656 catch(java.io.IOException e) {
657 jjStopStringLiteralDfa_0(5, active0, 0L);
658 return 6;
659 }
660 switch(curChar)
661 {
662 case 97:
663 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L);
664 case 99:
665 return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L);
666 case 101:
667 if ((active0 & 0x100000000000L) != 0L)
668 return jjStartNfaWithStates_0(6, 44, 32);
669 else if ((active0 & 0x200000000000L) != 0L)
670 return jjStartNfaWithStates_0(6, 45, 32);
671 return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L);
672 case 102:
673 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
674 case 108:
675 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L);
676 case 110:
677 if ((active0 & 0x4000L) != 0L)
678 return jjStartNfaWithStates_0(6, 14, 32);
679 break;
680 case 111:
681 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L);
682 case 115:
683 if ((active0 & 0x8000000L) != 0L)
684 return jjStartNfaWithStates_0(6, 27, 32);
685 break;
686 case 116:
687 if ((active0 & 0x800000L) != 0L)
688 return jjStartNfaWithStates_0(6, 23, 32);
689 return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L);
690 case 117:
691 return jjMoveStringLiteralDfa7_0(active0, 0x400000L);
692 case 121:
693 if ((active0 & 0x40000000L) != 0L)
694 return jjStartNfaWithStates_0(6, 30, 32);
695 break;
696 default :
697 break;
698 }
699 return jjStartNfa_0(5, active0, 0L);
700 }
701 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
702 {
703 if (((active0 &= old0)) == 0L)
704 return jjStartNfa_0(5, old0, 0L);
705 try { curChar = input_stream.readChar(); }
706 catch(java.io.IOException e) {
707 jjStopStringLiteralDfa_0(6, active0, 0L);
708 return 7;
709 }
710 switch(curChar)
711 {
712 case 99:
713 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L);
714 case 101:
715 if ((active0 & 0x400000L) != 0L)
716 return jjStartNfaWithStates_0(7, 22, 32);
717 else if ((active0 & 0x2000000000000000L) != 0L)
718 return jjStartNfaWithStates_0(7, 61, 32);
719 return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L);
720 case 110:
721 return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L);
722 case 112:
723 if ((active0 & 0x8000000000000000L) != 0L)
724 return jjStartNfaWithStates_0(7, 63, 32);
725 break;
726 case 116:
727 if ((active0 & 0x2000L) != 0L)
728 return jjStartNfaWithStates_0(7, 13, 32);
729 break;
730 default :
731 break;
732 }
733 return jjStartNfa_0(6, active0, 0L);
734 }
735 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
736 {
737 if (((active0 &= old0)) == 0L)
738 return jjStartNfa_0(6, old0, 0L);
739 try { curChar = input_stream.readChar(); }
740 catch(java.io.IOException e) {
741 jjStopStringLiteralDfa_0(7, active0, 0L);
742 return 8;
743 }
744 switch(curChar)
745 {
746 case 100:
747 if ((active0 & 0x400000000000L) != 0L)
748 return jjStartNfaWithStates_0(8, 46, 32);
749 break;
750 case 101:
751 if ((active0 & 0x8000000000L) != 0L)
752 return jjStartNfaWithStates_0(8, 39, 32);
753 break;
754 case 105:
755 return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);
756 case 111:
757 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
758 case 116:
759 if ((active0 & 0x200000000000000L) != 0L)
760 return jjStartNfaWithStates_0(8, 57, 32);
761 return jjMoveStringLiteralDfa9_0(active0, 0x800000000L);
762 default :
763 break;
764 }
765 return jjStartNfa_0(7, active0, 0L);
766 }
767 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
768 {
769 if (((active0 &= old0)) == 0L)
770 return jjStartNfa_0(7, old0, 0L);
771 try { curChar = input_stream.readChar(); }
772 catch(java.io.IOException e) {
773 jjStopStringLiteralDfa_0(8, active0, 0L);
774 return 9;
775 }
776 switch(curChar)
777 {
778 case 102:
779 if ((active0 & 0x2000000000L) != 0L)
780 return jjStartNfaWithStates_0(9, 37, 32);
781 break;
782 case 115:
783 if ((active0 & 0x800000000L) != 0L)
784 return jjStartNfaWithStates_0(9, 35, 32);
785 break;
786 case 122:
787 return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);
788 default :
789 break;
790 }
791 return jjStartNfa_0(8, active0, 0L);
792 }
793 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
794 {
795 if (((active0 &= old0)) == 0L)
796 return jjStartNfa_0(8, old0, 0L);
797 try { curChar = input_stream.readChar(); }
798 catch(java.io.IOException e) {
799 jjStopStringLiteralDfa_0(9, active0, 0L);
800 return 10;
801 }
802 switch(curChar)
803 {
804 case 101:
805 return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L);
806 default :
807 break;
808 }
809 return jjStartNfa_0(9, active0, 0L);
810 }
811 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
812 {
813 if (((active0 &= old0)) == 0L)
814 return jjStartNfa_0(9, old0, 0L);
815 try { curChar = input_stream.readChar(); }
816 catch(java.io.IOException e) {
817 jjStopStringLiteralDfa_0(10, active0, 0L);
818 return 11;
819 }
820 switch(curChar)
821 {
822 case 100:
823 if ((active0 & 0x20000000000000L) != 0L)
824 return jjStartNfaWithStates_0(11, 53, 32);
825 break;
826 default :
827 break;
828 }
829 return jjStartNfa_0(10, active0, 0L);
830 }
831 private final void jjCheckNAdd(int state)
832 {
833 if (jjrounds[state] != jjround)
834 {
835 jjstateSet[jjnewStateCnt++] = state;
836 jjrounds[state] = jjround;
837 }
838 }
839 private final void jjAddStates(int start, int end)
840 {
841 do {
842 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
843 } while (start++ != end);
844 }
845 private final void jjCheckNAddTwoStates(int state1, int state2)
846 {
847 jjCheckNAdd(state1);
848 jjCheckNAdd(state2);
849 }
850 private final void jjCheckNAddStates(int start, int end)
851 {
852 do {
853 jjCheckNAdd(jjnextStates[start]);
854 } while (start++ != end);
855 }
856 private final void jjCheckNAddStates(int start)
857 {
858 jjCheckNAdd(jjnextStates[start]);
859 jjCheckNAdd(jjnextStates[start + 1]);
860 }
861 static final long[] jjbitVec0 = {
862 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
863 };
864 static final long[] jjbitVec2 = {
865 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
866 };
867 static final long[] jjbitVec3 = {
868 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
869 };
870 static final long[] jjbitVec4 = {
871 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
872 };
873 static final long[] jjbitVec5 = {
874 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
875 };
876 static final long[] jjbitVec6 = {
877 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
878 };
879 static final long[] jjbitVec7 = {
880 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
881 };
882 static final long[] jjbitVec8 = {
883 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
884 };
885 private final int jjMoveNfa_0(int startState, int curPos)
886 {
887 int[] nextStates;
888 int startsAt = 0;
889 jjnewStateCnt = 52;
890 int i = 1;
891 jjstateSet[0] = startState;
892 int j, kind = 0x7fffffff;
893 for (;;)
894 {
895 if (++jjround == 0x7fffffff)
896 ReInitRounds();
897 if (curChar < 64)
898 {
899 long l = 1L << curChar;
900 MatchLoop: do
901 {
902 switch(jjstateSet[--i])
903 {
904 case 3:
905 if ((0x3ff000000000000L & l) != 0L)
906 jjCheckNAddStates(0, 6);
907 else if (curChar == 36)
908 {
909 if (kind > 73)
910 kind = 73;
911 jjCheckNAdd(32);
912 }
913 else if (curChar == 34)
914 jjCheckNAddStates(7, 9);
915 else if (curChar == 39)
916 jjAddStates(10, 11);
917 else if (curChar == 46)
918 jjCheckNAdd(8);
919 else if (curChar == 47)
920 jjstateSet[jjnewStateCnt++] = 2;
921 if ((0x3fe000000000000L & l) != 0L)
922 {
923 if (kind > 65)
924 kind = 65;
925 jjCheckNAddTwoStates(5, 6);
926 }
927 else if (curChar == 48)
928 {
929 if (kind > 65)
930 kind = 65;
931 jjCheckNAddStates(12, 14);
932 }
933 break;
934 case 0:
935 if (curChar == 42)
936 jjstateSet[jjnewStateCnt++] = 1;
937 break;
938 case 1:
939 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
940 kind = 7;
941 break;
942 case 2:
943 if (curChar == 42)
944 jjstateSet[jjnewStateCnt++] = 0;
945 break;
946 case 4:
947 if ((0x3fe000000000000L & l) == 0L)
948 break;
949 if (kind > 65)
950 kind = 65;
951 jjCheckNAddTwoStates(5, 6);
952 break;
953 case 5:
954 if ((0x3ff000000000000L & l) == 0L)
955 break;
956 if (kind > 65)
957 kind = 65;
958 jjCheckNAddTwoStates(5, 6);
959 break;
960 case 7:
961 if (curChar == 46)
962 jjCheckNAdd(8);
963 break;
964 case 8:
965 if ((0x3ff000000000000L & l) == 0L)
966 break;
967 if (kind > 69)
968 kind = 69;
969 jjCheckNAddStates(15, 17);
970 break;
971 case 10:
972 if ((0x280000000000L & l) != 0L)
973 jjCheckNAdd(11);
974 break;
975 case 11:
976 if ((0x3ff000000000000L & l) == 0L)
977 break;
978 if (kind > 69)
979 kind = 69;
980 jjCheckNAddTwoStates(11, 12);
981 break;
982 case 13:
983 if (curChar == 39)
984 jjAddStates(10, 11);
985 break;
986 case 14:
987 if ((0xffffff7fffffdbffL & l) != 0L)
988 jjCheckNAdd(15);
989 break;
990 case 15:
991 if (curChar == 39 && kind > 71)
992 kind = 71;
993 break;
994 case 17:
995 if ((0x8400000000L & l) != 0L)
996 jjCheckNAdd(15);
997 break;
998 case 18:
999 if ((0xff000000000000L & l) != 0L)
1000 jjCheckNAddTwoStates(19, 15);
1001 break;
1002 case 19:
1003 if ((0xff000000000000L & l) != 0L)
1004 jjCheckNAdd(15);
1005 break;
1006 case 20:
1007 if ((0xf000000000000L & l) != 0L)
1008 jjstateSet[jjnewStateCnt++] = 21;
1009 break;
1010 case 21:
1011 if ((0xff000000000000L & l) != 0L)
1012 jjCheckNAdd(19);
1013 break;
1014 case 22:
1015 if (curChar == 34)
1016 jjCheckNAddStates(7, 9);
1017 break;
1018 case 23:
1019 if ((0xfffffffbffffdbffL & l) != 0L)
1020 jjCheckNAddStates(7, 9);
1021 break;
1022 case 25:
1023 if ((0x8400000000L & l) != 0L)
1024 jjCheckNAddStates(7, 9);
1025 break;
1026 case 26:
1027 if (curChar == 34 && kind > 72)
1028 kind = 72;
1029 break;
1030 case 27:
1031 if ((0xff000000000000L & l) != 0L)
1032 jjCheckNAddStates(18, 21);
1033 break;
1034 case 28:
1035 if ((0xff000000000000L & l) != 0L)
1036 jjCheckNAddStates(7, 9);
1037 break;
1038 case 29:
1039 if ((0xf000000000000L & l) != 0L)
1040 jjstateSet[jjnewStateCnt++] = 30;
1041 break;
1042 case 30:
1043 if ((0xff000000000000L & l) != 0L)
1044 jjCheckNAdd(28);
1045 break;
1046 case 31:
1047 if (curChar != 36)
1048 break;
1049 if (kind > 73)
1050 kind = 73;
1051 jjCheckNAdd(32);
1052 break;
1053 case 32:
1054 if ((0x3ff001000000000L & l) == 0L)
1055 break;
1056 if (kind > 73)
1057 kind = 73;
1058 jjCheckNAdd(32);
1059 break;
1060 case 33:
1061 if ((0x3ff000000000000L & l) != 0L)
1062 jjCheckNAddStates(0, 6);
1063 break;
1064 case 34:
1065 if ((0x3ff000000000000L & l) != 0L)
1066 jjCheckNAddTwoStates(34, 35);
1067 break;
1068 case 35:
1069 if (curChar != 46)
1070 break;
1071 if (kind > 69)
1072 kind = 69;
1073 jjCheckNAddStates(22, 24);
1074 break;
1075 case 36:
1076 if ((0x3ff000000000000L & l) == 0L)
1077 break;
1078 if (kind > 69)
1079 kind = 69;
1080 jjCheckNAddStates(22, 24);
1081 break;
1082 case 38:
1083 if ((0x280000000000L & l) != 0L)
1084 jjCheckNAdd(39);
1085 break;
1086 case 39:
1087 if ((0x3ff000000000000L & l) == 0L)
1088 break;
1089 if (kind > 69)
1090 kind = 69;
1091 jjCheckNAddTwoStates(39, 12);
1092 break;
1093 case 40:
1094 if ((0x3ff000000000000L & l) != 0L)
1095 jjCheckNAddTwoStates(40, 41);
1096 break;
1097 case 42:
1098 if ((0x280000000000L & l) != 0L)
1099 jjCheckNAdd(43);
1100 break;
1101 case 43:
1102 if ((0x3ff000000000000L & l) == 0L)
1103 break;
1104 if (kind > 69)
1105 kind = 69;
1106 jjCheckNAddTwoStates(43, 12);
1107 break;
1108 case 44:
1109 if ((0x3ff000000000000L & l) != 0L)
1110 jjCheckNAddStates(25, 27);
1111 break;
1112 case 46:
1113 if ((0x280000000000L & l) != 0L)
1114 jjCheckNAdd(47);
1115 break;
1116 case 47:
1117 if ((0x3ff000000000000L & l) != 0L)
1118 jjCheckNAddTwoStates(47, 12);
1119 break;
1120 case 48:
1121 if (curChar != 48)
1122 break;
1123 if (kind > 65)
1124 kind = 65;
1125 jjCheckNAddStates(12, 14);
1126 break;
1127 case 50:
1128 if ((0x3ff000000000000L & l) == 0L)
1129 break;
1130 if (kind > 65)
1131 kind = 65;
1132 jjCheckNAddTwoStates(50, 6);
1133 break;
1134 case 51:
1135 if ((0xff000000000000L & l) == 0L)
1136 break;
1137 if (kind > 65)
1138 kind = 65;
1139 jjCheckNAddTwoStates(51, 6);
1140 break;
1141 default : break;
1142 }
1143 } while(i != startsAt);
1144 }
1145 else if (curChar < 128)
1146 {
1147 long l = 1L << (curChar & 077);
1148 MatchLoop: do
1149 {
1150 switch(jjstateSet[--i])
1151 {
1152 case 3:
1153 case 32:
1154 if ((0x7fffffe87fffffeL & l) == 0L)
1155 break;
1156 if (kind > 73)
1157 kind = 73;
1158 jjCheckNAdd(32);
1159 break;
1160 case 1:
1161 if (kind > 7)
1162 kind = 7;
1163 break;
1164 case 6:
1165 if ((0x100000001000L & l) != 0L && kind > 65)
1166 kind = 65;
1167 break;
1168 case 9:
1169 if ((0x2000000020L & l) != 0L)
1170 jjAddStates(28, 29);
1171 break;
1172 case 12:
1173 if ((0x5000000050L & l) != 0L && kind > 69)
1174 kind = 69;
1175 break;
1176 case 14:
1177 if ((0xffffffffefffffffL & l) != 0L)
1178 jjCheckNAdd(15);
1179 break;
1180 case 16:
1181 if (curChar == 92)
1182 jjAddStates(30, 32);
1183 break;
1184 case 17:
1185 if ((0x14404410000000L & l) != 0L)
1186 jjCheckNAdd(15);
1187 break;
1188 case 23:
1189 if ((0xffffffffefffffffL & l) != 0L)
1190 jjCheckNAddStates(7, 9);
1191 break;
1192 case 24:
1193 if (curChar == 92)
1194 jjAddStates(33, 35);
1195 break;
1196 case 25:
1197 if ((0x14404410000000L & l) != 0L)
1198 jjCheckNAddStates(7, 9);
1199 break;
1200 case 37:
1201 if ((0x2000000020L & l) != 0L)
1202 jjAddStates(36, 37);
1203 break;
1204 case 41:
1205 if ((0x2000000020L & l) != 0L)
1206 jjAddStates(38, 39);
1207 break;
1208 case 45:
1209 if ((0x2000000020L & l) != 0L)
1210 jjAddStates(40, 41);
1211 break;
1212 case 49:
1213 if ((0x100000001000000L & l) != 0L)
1214 jjCheckNAdd(50);
1215 break;
1216 case 50:
1217 if ((0x7e0000007eL & l) == 0L)
1218 break;
1219 if (kind > 65)
1220 kind = 65;
1221 jjCheckNAddTwoStates(50, 6);
1222 break;
1223 default : break;
1224 }
1225 } while(i != startsAt);
1226 }
1227 else
1228 {
1229 int hiByte = (int)(curChar >> 8);
1230 int i1 = hiByte >> 6;
1231 long l1 = 1L << (hiByte & 077);
1232 int i2 = (curChar & 0xff) >> 6;
1233 long l2 = 1L << (curChar & 077);
1234 MatchLoop: do
1235 {
1236 switch(jjstateSet[--i])
1237 {
1238 case 3:
1239 case 32:
1240 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1241 break;
1242 if (kind > 73)
1243 kind = 73;
1244 jjCheckNAdd(32);
1245 break;
1246 case 1:
1247 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1248 kind = 7;
1249 break;
1250 case 14:
1251 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1252 jjstateSet[jjnewStateCnt++] = 15;
1253 break;
1254 case 23:
1255 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1256 jjAddStates(7, 9);
1257 break;
1258 default : break;
1259 }
1260 } while(i != startsAt);
1261 }
1262 if (kind != 0x7fffffff)
1263 {
1264 jjmatchedKind = kind;
1265 jjmatchedPos = curPos;
1266 kind = 0x7fffffff;
1267 }
1268 ++curPos;
1269 if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
1270 return curPos;
1271 try { curChar = input_stream.readChar(); }
1272 catch(java.io.IOException e) { return curPos; }
1273 }
1274 }
1275 private final int jjMoveStringLiteralDfa0_3()
1276 {
1277 switch(curChar)
1278 {
1279 case 42:
1280 return jjMoveStringLiteralDfa1_3(0x800L);
1281 default :
1282 return 1;
1283 }
1284 }
1285 private final int jjMoveStringLiteralDfa1_3(long active0)
1286 {
1287 try { curChar = input_stream.readChar(); }
1288 catch(java.io.IOException e) {
1289 return 1;
1290 }
1291 switch(curChar)
1292 {
1293 case 47:
1294 if ((active0 & 0x800L) != 0L)
1295 return jjStopAtPos(1, 11);
1296 break;
1297 default :
1298 return 2;
1299 }
1300 return 2;
1301 }
1302 private final int jjMoveStringLiteralDfa0_1()
1303 {
1304 return jjMoveNfa_1(0, 0);
1305 }
1306 private final int jjMoveNfa_1(int startState, int curPos)
1307 {
1308 int[] nextStates;
1309 int startsAt = 0;
1310 jjnewStateCnt = 3;
1311 int i = 1;
1312 jjstateSet[0] = startState;
1313 int j, kind = 0x7fffffff;
1314 for (;;)
1315 {
1316 if (++jjround == 0x7fffffff)
1317 ReInitRounds();
1318 if (curChar < 64)
1319 {
1320 long l = 1L << curChar;
1321 MatchLoop: do
1322 {
1323 switch(jjstateSet[--i])
1324 {
1325 case 0:
1326 if ((0x2400L & l) != 0L)
1327 {
1328 if (kind > 9)
1329 kind = 9;
1330 }
1331 if (curChar == 13)
1332 jjstateSet[jjnewStateCnt++] = 1;
1333 break;
1334 case 1:
1335 if (curChar == 10 && kind > 9)
1336 kind = 9;
1337 break;
1338 case 2:
1339 if (curChar == 13)
1340 jjstateSet[jjnewStateCnt++] = 1;
1341 break;
1342 default : break;
1343 }
1344 } while(i != startsAt);
1345 }
1346 else if (curChar < 128)
1347 {
1348 long l = 1L << (curChar & 077);
1349 MatchLoop: do
1350 {
1351 switch(jjstateSet[--i])
1352 {
1353 default : break;
1354 }
1355 } while(i != startsAt);
1356 }
1357 else
1358 {
1359 int hiByte = (int)(curChar >> 8);
1360 int i1 = hiByte >> 6;
1361 long l1 = 1L << (hiByte & 077);
1362 int i2 = (curChar & 0xff) >> 6;
1363 long l2 = 1L << (curChar & 077);
1364 MatchLoop: do
1365 {
1366 switch(jjstateSet[--i])
1367 {
1368 default : break;
1369 }
1370 } while(i != startsAt);
1371 }
1372 if (kind != 0x7fffffff)
1373 {
1374 jjmatchedKind = kind;
1375 jjmatchedPos = curPos;
1376 kind = 0x7fffffff;
1377 }
1378 ++curPos;
1379 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1380 return curPos;
1381 try { curChar = input_stream.readChar(); }
1382 catch(java.io.IOException e) { return curPos; }
1383 }
1384 }
1385 private final int jjMoveStringLiteralDfa0_2()
1386 {
1387 switch(curChar)
1388 {
1389 case 42:
1390 return jjMoveStringLiteralDfa1_2(0x400L);
1391 default :
1392 return 1;
1393 }
1394 }
1395 private final int jjMoveStringLiteralDfa1_2(long active0)
1396 {
1397 try { curChar = input_stream.readChar(); }
1398 catch(java.io.IOException e) {
1399 return 1;
1400 }
1401 switch(curChar)
1402 {
1403 case 47:
1404 if ((active0 & 0x400L) != 0L)
1405 return jjStopAtPos(1, 10);
1406 break;
1407 default :
1408 return 2;
1409 }
1410 return 2;
1411 }
1412 static final int[] jjnextStates = {
1413 34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8,
1414 9, 12, 23, 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18,
1415 20, 25, 27, 29, 38, 39, 42, 43, 46, 47,
1416 };
1417 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1418 {
1419 switch(hiByte)
1420 {
1421 case 0:
1422 return ((jjbitVec2[i2] & l2) != 0L);
1423 default :
1424 if ((jjbitVec0[i1] & l1) != 0L)
1425 return true;
1426 return false;
1427 }
1428 }
1429 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1430 {
1431 switch(hiByte)
1432 {
1433 case 0:
1434 return ((jjbitVec4[i2] & l2) != 0L);
1435 case 48:
1436 return ((jjbitVec5[i2] & l2) != 0L);
1437 case 49:
1438 return ((jjbitVec6[i2] & l2) != 0L);
1439 case 51:
1440 return ((jjbitVec7[i2] & l2) != 0L);
1441 case 61:
1442 return ((jjbitVec8[i2] & l2) != 0L);
1443 default :
1444 if ((jjbitVec3[i1] & l1) != 0L)
1445 return true;
1446 return false;
1447 }
1448 }
1449 public static final String[] jjstrLiteralImages = {
1450 "", null, null, null, null, null, null, null, null, null, null, null, null,
1451 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
1452 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
1453 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1454 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1455 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
1456 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
1457 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146",
1458 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1459 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1460 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
1461 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
1462 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
1463 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
1464 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1465 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", "\141\163\163\145\162\164", null, null,
1466 null, null, null, null, null, null, null, null, null, "\50", "\51", "\173", "\175",
1467 "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74", "\41", "\176", "\77", "\72",
1468 "\75\75", "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53",
1469 "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76",
1470 "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75",
1471 "\74\74\75", "\76\76\75", "\76\76\76\75", };
1472 public static final String[] lexStateNames = {
1473 "DEFAULT",
1474 "IN_SINGLE_LINE_COMMENT",
1475 "IN_FORMAL_COMMENT",
1476 "IN_MULTI_LINE_COMMENT",
1477 };
1478 public static final int[] jjnewLexState = {
1479 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1480 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1481 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1482 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1483 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1484 };
1485 static final long[] jjtoToken = {
1486 0xffffffffffffe001L, 0x3fffffffffff3a3L,
1487 };
1488 static final long[] jjtoSkip = {
1489 0xe3eL, 0x0L,
1490 };
1491 static final long[] jjtoSpecial = {
1492 0xe00L, 0x0L,
1493 };
1494 static final long[] jjtoMore = {
1495 0x11c0L, 0x0L,
1496 };
1497 private JavaCharStream input_stream;
1498 private final int[] jjrounds = new int[52];
1499 private final int[] jjstateSet = new int[104];
1500 StringBuffer image;
1501 int jjimageLen;
1502 int lengthOfMatch;
1503 protected char curChar;
1504 public JavaParserTokenManager(JavaCharStream stream)
1505 {
1506 if (JavaCharStream.staticFlag)
1507 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1508 input_stream = stream;
1509 }
1510 public JavaParserTokenManager(JavaCharStream stream, int lexState)
1511 {
1512 this(stream);
1513 SwitchTo(lexState);
1514 }
1515 public void ReInit(JavaCharStream stream)
1516 {
1517 jjmatchedPos = jjnewStateCnt = 0;
1518 curLexState = defaultLexState;
1519 input_stream = stream;
1520 ReInitRounds();
1521 }
1522 private final void ReInitRounds()
1523 {
1524 int i;
1525 jjround = 0x80000001;
1526 for (i = 52; i-- > 0;)
1527 jjrounds[i] = 0x80000000;
1528 }
1529 public void ReInit(JavaCharStream stream, int lexState)
1530 {
1531 ReInit(stream);
1532 SwitchTo(lexState);
1533 }
1534 public void SwitchTo(int lexState)
1535 {
1536 if (lexState >= 4 || lexState < 0)
1537 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1538 else
1539 curLexState = lexState;
1540 }
1541
1542 private final Token jjFillToken()
1543 {
1544 Token t = Token.newToken(jjmatchedKind);
1545 t.kind = jjmatchedKind;
1546 String im = jjstrLiteralImages[jjmatchedKind];
1547 t.image = (im == null) ? input_stream.GetImage() : im;
1548 t.beginLine = input_stream.getBeginLine();
1549 t.beginColumn = input_stream.getBeginColumn();
1550 t.endLine = input_stream.getEndLine();
1551 t.endColumn = input_stream.getEndColumn();
1552 return t;
1553 }
1554
1555 int curLexState = 0;
1556 int defaultLexState = 0;
1557 int jjnewStateCnt;
1558 int jjround;
1559 int jjmatchedPos;
1560 int jjmatchedKind;
1561
1562 public final Token getNextToken()
1563 {
1564 int kind;
1565 Token specialToken = null;
1566 Token matchedToken;
1567 int curPos = 0;
1568
1569 EOFLoop :
1570 for (;;)
1571 {
1572 try
1573 {
1574 curChar = input_stream.BeginToken();
1575 }
1576 catch(java.io.IOException e)
1577 {
1578 jjmatchedKind = 0;
1579 matchedToken = jjFillToken();
1580 matchedToken.specialToken = specialToken;
1581 return matchedToken;
1582 }
1583 image = null;
1584 jjimageLen = 0;
1585
1586 for (;;)
1587 {
1588 switch(curLexState)
1589 {
1590 case 0:
1591 try { input_stream.backup(0);
1592 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1593 curChar = input_stream.BeginToken();
1594 }
1595 catch (java.io.IOException e1) { continue EOFLoop; }
1596 jjmatchedKind = 0x7fffffff;
1597 jjmatchedPos = 0;
1598 curPos = jjMoveStringLiteralDfa0_0();
1599 break;
1600 case 1:
1601 jjmatchedKind = 0x7fffffff;
1602 jjmatchedPos = 0;
1603 curPos = jjMoveStringLiteralDfa0_1();
1604 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1605 {
1606 jjmatchedKind = 12;
1607 }
1608 break;
1609 case 2:
1610 jjmatchedKind = 0x7fffffff;
1611 jjmatchedPos = 0;
1612 curPos = jjMoveStringLiteralDfa0_2();
1613 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1614 {
1615 jjmatchedKind = 12;
1616 }
1617 break;
1618 case 3:
1619 jjmatchedKind = 0x7fffffff;
1620 jjmatchedPos = 0;
1621 curPos = jjMoveStringLiteralDfa0_3();
1622 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1623 {
1624 jjmatchedKind = 12;
1625 }
1626 break;
1627 }
1628 if (jjmatchedKind != 0x7fffffff)
1629 {
1630 if (jjmatchedPos + 1 < curPos)
1631 input_stream.backup(curPos - jjmatchedPos - 1);
1632 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1633 {
1634 matchedToken = jjFillToken();
1635 matchedToken.specialToken = specialToken;
1636 if (jjnewLexState[jjmatchedKind] != -1)
1637 curLexState = jjnewLexState[jjmatchedKind];
1638 return matchedToken;
1639 }
1640 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1641 {
1642 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1643 {
1644 matchedToken = jjFillToken();
1645 if (specialToken == null)
1646 specialToken = matchedToken;
1647 else
1648 {
1649 matchedToken.specialToken = specialToken;
1650 specialToken = (specialToken.next = matchedToken);
1651 }
1652 SkipLexicalActions(matchedToken);
1653 }
1654 else
1655 SkipLexicalActions(null);
1656 if (jjnewLexState[jjmatchedKind] != -1)
1657 curLexState = jjnewLexState[jjmatchedKind];
1658 continue EOFLoop;
1659 }
1660 MoreLexicalActions();
1661 if (jjnewLexState[jjmatchedKind] != -1)
1662 curLexState = jjnewLexState[jjmatchedKind];
1663 curPos = 0;
1664 jjmatchedKind = 0x7fffffff;
1665 try {
1666 curChar = input_stream.readChar();
1667 continue;
1668 }
1669 catch (java.io.IOException e1) { }
1670 }
1671 int error_line = input_stream.getEndLine();
1672 int error_column = input_stream.getEndColumn();
1673 String error_after = null;
1674 boolean EOFSeen = false;
1675 try { input_stream.readChar(); input_stream.backup(1); }
1676 catch (java.io.IOException e1) {
1677 EOFSeen = true;
1678 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1679 if (curChar == '\n' || curChar == '\r') {
1680 error_line++;
1681 error_column = 0;
1682 }
1683 else
1684 error_column++;
1685 }
1686 if (!EOFSeen) {
1687 input_stream.backup(1);
1688 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1689 }
1690 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1691 }
1692 }
1693 }
1694
1695 final void SkipLexicalActions(Token matchedToken)
1696 {
1697 switch(jjmatchedKind)
1698 {
1699 default :
1700 break;
1701 }
1702 }
1703 final void MoreLexicalActions()
1704 {
1705 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1706 switch(jjmatchedKind)
1707 {
1708 case 7 :
1709 if (image == null)
1710 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
1711 else
1712 image.append(input_stream.GetSuffix(jjimageLen));
1713 jjimageLen = 0;
1714 input_stream.backup(1);
1715 break;
1716 default :
1717 break;
1718 }
1719 }
1720 }
This page was automatically generated by Maven